home *** CD-ROM | disk | FTP | other *** search
/ Power Tools 1993 November - Disc 2 / Power Tools Plus (Disc 2 of 2)(November 1993)(HP).iso / hotlines / wsyhl / uimx / pre.cpy / SCRIPT.TXT next >
Text File  |  1993-06-26  |  10KB  |  265 lines
  1. UIM/X 2.5: Mini Presentation (June '93)
  2.  
  3. -----------------------------------------------
  4.  
  5. The five slides used in this presentation are part of the master
  6. SESD product strategy slide set.  A more detailed slide set can
  7. be obtained by contacting Dave Wright (UIM/X  Product Manager)
  8. at:  T/303 229-6987, via HPDesk: David R Wright / HP4000/30, or
  9. via email: davew@fc.sde.hp.com.
  10.  
  11.  
  12.  
  13. Slide 1:   UIM/X: Graphical User Interface (GUI) Builder
  14.  
  15. -----------------------------------------------------------------
  16. ---
  17.  
  18.  UIM/X from HP  is a comprehensive second generation Graphical
  19. User Interface Builder. UIM/X is developed by Visual Edge
  20. Software Ltd, (Montreal, Canada) and is sold by HP on HP-UX
  21. systems.  UIM/X enhances programmer productivity by enabling
  22. software developers to interactively create, modify, test and
  23. generate code for the user interface portion of their
  24. applications. During this presentation we will discuss UIM/X's
  25. leadership position in the market place; how UIM/X supports the
  26. full GUI development process; UIM/X's features and functionality
  27. as a User Interface Management System (UIMS); and what is new
  28. with version 2.5.
  29.  
  30.  
  31.  
  32. Slide 2:  UIM/X dominates the GUI builder market
  33.  
  34. ------------------------------------------------------------
  35.  
  36. Few products dominate their market like UIM/X has dominated the
  37. area of UNIX GUI builders. HP's is the number one supplier of
  38. UIM/X worldwide.  The quotes from SunWorld and UNIXWorld are
  39. only two of many that reemphasize this dominant position.
  40. Recent reports show that UIM/X holds nearly an 80% share of the
  41. Motif UIMS builder market and over 50% of the Motif focused
  42. UIMS/Layout market. But now is not a time to get comfortable.
  43. The competition is scrambling to catch up. With the release of
  44. UIM/X 2.5, which we will discuss in more detail later, they (the
  45. competition) will need to scramble even harder.  Much of UIM/X's
  46. market success is tied to the three goals under which the
  47. product was developed: 1) provide the most complete environment
  48. possible for GUI development; 2) offer the highest degree of
  49. programmer productivity; and 3) be the most intuitive tool on
  50. the market.
  51.  
  52.  
  53.  
  54. Slide 3:  UIM/X supports the GUI development process
  55.  
  56. -----------------------------------------------------------------
  57.  
  58. Before we dwell on UIM/X's feature set, it is important to
  59. review the steps involved in creating a GUI.  Using these steps
  60. as a baseline, it is easier to measure to what extent  any GUI
  61. builder product will assist a developer.
  62.  
  63.  
  64.  
  65. Layout:  Layout consists of creating interface components from
  66. widget primitives which adhere to a specific Style Guide (Motif,
  67. corporate, Windows, ...) and laying out the GUI elements which
  68. are specific to the application being developed.
  69.  
  70.  
  71.  
  72. Behavior:  Once the interface  layout is complete, behavior
  73. associated with the interface must be defined.  This includes
  74. defining callbacks; handling application window events and
  75. setting the dynamic elements of the initial state of the
  76. application.
  77.  
  78.  
  79.  
  80. Testing & Refinement: This is an ongoing part of the whole GUI
  81. development process. Some builders lend themselves better than
  82. others to a successive refinement approach to testing and
  83. refinement.
  84.  
  85.  
  86.  
  87. Code Generation:  The ultimate goal is to generate code which
  88. represents the interface.  The real test of a builder is how
  89. useful it can be once initial code is generated.
  90.  
  91.  
  92.  
  93. Slide 4:  UIM/X full function UIMS
  94.  
  95. ------------------------------------------
  96.  
  97. UIM/X is a full function User Interface Management System (UIMS)
  98. which supports the complete GUI development process. UIMS's
  99. differ from Interface Design (Layout) tools. They not only allow
  100. for interactive interface layout and automatic code generation,
  101. they also aid the developer with integration of an interface to
  102. its application code.
  103.  
  104.  
  105.  
  106. UIM/X is based on standards such as OSF/Motif and ANSI C.  It is
  107. actually the only builder which supports the entire Motif
  108. toolkit.  Developers use a what you see is what you get (WSIWIG)
  109. editor to graphically choose any OSF/Motif widget and layout
  110. their interface. Widgets can be selected, moved, resized,
  111. copied, cut, pasted ...  With the GUI object class component
  112. feature, reusable interface components and the interfaces that
  113. use them can be created at the same time.  Additionally there
  114. are a variety of specialized editors/browsers which are smoothly
  115. integrated through the consistent use of a drag-and-drop
  116. metaphor.
  117.  
  118.  
  119.  
  120. UIM/X enables developers to define, modify and test behavior in
  121. the builder.  C code callbacks can be typed directly into the
  122. menu editor.  the callback code is kept as part of the
  123. definition of the project, so there is no need to modify
  124. generated C code, or merge in changes each time the GUI is
  125. modified.  Developers can use X, Xm, or Xt function calls, all
  126. of which are linked into UIM/X.  Translation tables can be used
  127. to customize the behavior of existing widgets and C expressions
  128. can be entered for the value of any property, so initial values
  129. can be determined at runtime  -- without modifying generated
  130. source code.
  131.  
  132.  
  133.  
  134. With the integrated C interpreter, developers can test and
  135. refine/modify their interfaces with the underlying application
  136. connected and running.  The interpreter can mix compiled and
  137. interpreted code and is tightly integrated, so there is no need
  138. to generate code, recompile, relink and restart execution each
  139. time a change is made.
  140.  
  141.  
  142.  
  143. Using UIM/X the developer can minimize the time consuming
  144. testing cycles which are common in GUI software development.
  145. This integrated environment also means that developers have
  146. access to a working prototype the entire time they are
  147. developing their interface.  UIM/X generates C (ANSI or K&R),
  148. C++ and UIL code and either pure OSF/Motif code or  UIM/X
  149. convenience library code.  With UIM/X once you generate code you
  150. are done with interface development. UIM/X also generates  a
  151. customizable main program and makefile.
  152.  
  153.  
  154.  
  155. UIM/X lets developers construct interfaces out of reusable GUI
  156. object classes (components).  Developers can construct entire
  157. interfaces out of these components and the resulting interface
  158. code is portable and separate from their GUI component
  159. implementation.
  160.  
  161.  
  162.  
  163. Finally, UIM/X can be used to create iconic interfaces for
  164. existing keyboard applications. This helps protect a company's
  165. investment in their legacy applications as they move to UNIX.
  166. As you can see UIM/X really does support entire process outlined
  167. in the previous slide.
  168.  
  169.  
  170.  
  171. Slide 5:  UIM/X 2.5: The best gets Better
  172.  
  173. -------------------------------------------------
  174.  
  175. Version 2.5 of UIM/X continues in the tradition of past versions
  176. offering not only increased functionality, but improved ease of
  177. use, flexibility and quality.  Key features of this release
  178. include:
  179.  
  180.  
  181.  
  182. 100% support for Motif 1.2: UIM/X supports 100% of the OSF/Motif
  183. 1.2 toolkit -- all shells, widgets, gadgets, convenience dialogs
  184. and resources.
  185.  
  186.  
  187.  
  188. C++ Code Generation:  When generating C++ code, UIM/X takes
  189. advantage of the object-oriented features of C++.   Components
  190. are generated as true C++ object classes, properties become data
  191. members and methods become member functions.
  192.  
  193.  
  194.  
  195. GUI object class components:  Users can build, using
  196. drag-anddrop, reusable GUI object class components which comply
  197. with the OMG CORBA C API specification.  Components combined
  198. with C++ code generation capabilities enable developers to
  199. create user interfaces out of custom-built portable GUI class
  200. components. This "quality in portability" approach is far
  201. superior to what can be achieved using "lowest common
  202. denominator" tools.  Developers are able to create their
  203. interfaces of GUI object class components which utilize
  204. inheritance, encapsulation and polymorphism gaining a smooth
  205. migration from C to C++, protecting your software investment
  206. through standards adherence
  207.  
  208.  
  209.  
  210. UIM/X widget palette:  With the new widget palette even novice
  211. users can rapidly become productive.  Each widget, shell,
  212. manager ..., is represented by an icon which is much more
  213. accessible than the old menu structure. Palettes can be tailored
  214. to adhere to corporate standards, or can be customized to an
  215. individual's programming preferences.
  216.  
  217.  
  218.  
  219. SoftBench Integration:  From SoftBench a user can start, stop,
  220. set working directory, iconify and normalize UIM/X.  UIM/X uses
  221. SoftBench's version control tool, editor and build tool.  Users
  222. can also load UIM/X project, interface and palette files.
  223. Developers benefit from smooth access to the best interface and
  224. application development environments on UNIX today.
  225.  
  226.  
  227.  
  228. Builder Engine:  UIM/X consists of a core GUI Builder Engine
  229. surrounded by a set of tools and features.  The Builder Engine
  230. customization capabilities included in UIM/X 2.5 enable
  231. developers to customize and extend UIM/X, thereby increasing
  232. flexibility in developing production quality interfaces.
  233. Developers can plug new tools into the engine, modify existing
  234. tools or even remove unwanted capabilities from UIM/X.  Using
  235. the Builder Engine. you can customize UIM/X to support the
  236. definition and implementation of corporate-wide GUI standards,
  237. or to tailor and simplify it to meet the needs of a specific
  238. application or market.
  239.  
  240.  
  241.  
  242. UIM/X 2.5 also features other enhancements such as UIL
  243. read/write, automated documentation of GUI structures, improved
  244. performance & memory management, and additional options for code
  245. generation.
  246.  
  247.  
  248.  
  249. With this release, UIM/X strengthens its position as the market
  250. leading GUI builder for UNIX and sets a standard which will be
  251. difficult for other GUI builders to match.
  252.  
  253.  
  254.  
  255. Slide 6:  UIM/X -- SoftBench Integration
  256.  
  257. ------------------------------------------------
  258.  
  259. List of capabilities available via the latest integration
  260. between UIM/X and SoftBench.  These
  261.  
  262. capabilities are included in UIM/X.  No separate code is
  263. required.
  264.  
  265.